package com.somnus.androidkotlindemo.activity

import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import com.somnus.androidkotlindemo.R
import java.io.File
import java.util.Locale.filter

/**
 * https://wangjiegulu.gitbooks.io/kotlin-for-android-developers-zh/zong_shu_cao_zuo_fu.html
 * 学习 Kotlin 基本语法
 */
class KotlinBasicActivity : AppCompatActivity(), View.OnClickListener {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_kotlin_basic)


//        val listForEach = listOf(1,3,5,7,8)
//        listForEach.forEach {
//            if (it >3) return@forEach
//            print("ss")
//        }


        /****
         *        从forEach函数跳出：https://blog.csdn.net/zxc123e/article/details/73368781
         */

//        run outer@{
//            list.forEach {
//                if (it == 0) return@forEach //相当于在forEach函数中continue,实际上是从匿名函数返回
//                if (it == 2) return@outer //相当于在forEach函数中使用break,实际上是跳转到outer之外
//            }
//        }
//        if (i == 3)
//        {
//            //每个函数的名字代表一个函数地址，所以函数自动成为标签
//            return@forEach_label //等同于return
//        }
        /***
         *如何正确终止 forEach https://juejin.im/post/58fd31dd8d6d8100589813bf
         */
//        val list = listOf(1,3,4,5,6,7,9)
//        list.takeWhile { it <= 3 }.forEach(::println)
//        println("Hello")


        printSum(1, 3)

        printProduct("6", "7")
        printProduct("a", "7")
        printProduct("a", "b")


        val items = listOf(1, 2, 3)
        for (item in items) {
            println(item)
        }

        val items1 = listOf("apple", "banana", "kiwi")
        for (item in items1) {
            println(item)
        }


        val items2 = listOf("apple", "banana", "kiwi")
        var index = 0
        while (index < items2.size) {
            println("item at $index is ${items2[index]}")
            index++
        }

        /***
         * When
         */

        fun describe(obj: Any): String =
                when (obj) {
//                    1 -> "One"
                    is Int -> "is int"
                    true -> "True"
                    else -> "Unknow"
                }

        println("1:" + describe(1))
        println("boolean :" + describe(true))

        /**
         * Range 区间
         */

        var x = 10
        var y = 9
        if (x in 1..y + 1) {
            println("$x in Range")
        }

        var i: Int = 1
        for (i in 1..y + 1) {
            print("index $i ")
        }

        var list = listOf("a", "b", "c")
        val listS = list.size
        println("数组长度： $listS")
        val listIndex = list.lastIndex
        println("数组lastIndex： $listIndex")

        if (-1 in 0..list.lastIndex) {
            print("-1 is not of range")
        }
        val listIndices = list.indices
        println("数组indices： $listIndices")   //数组indices： 0..2
        if (list.size in listIndices) {
            println("list size is not of valid list indices range too")
        }

        when {
            "a" in list -> println("a aa")
            else -> println("UnKonw")
        }




//        Method()


//        区间
        //闭区间 ， 包含100
//        for (i in 1..100){
//            println(i)
//        }

        //开区间  不会包含100
        for (i in 1 until 100) {
            print(i)  //不执行？
        }

        println("--------------------------------------------------------------------------------------")
        for (x in 2..100 step 2) {
            print(x)
        }
        //等同于
        /***
         * for(x = 2;i<100;i+2)
         */
        println("--------------------------------------------------------------------------------------")

        //只读map
        val map = mapOf("a" to 1, "b" to 2, "b" to 3)
        println(map["b"])
        println(map["a"])


//        val p: String by lazy {
//            // 计算该字符串
//        }

//        if not null

        val files = File("Test").listFiles()
        println(files?.size)


//        try/catch 表达式/**/

//        fun test(){
//            val result = try {
//
//            }catch (e : ArithmeticException){
//                throw IllegalAccessError(e)
//            }
//        }


        arrayOfMinusOnes(1)



        fun theAnswer() = 23

        //等价于
        fun theAnswer2(): Int {
            return 23
        }

//        Unit

//        如果函数返回Unit类型，该返回类型应该省略

        fun foo() {//这里就省略了 ：Unit

        }

        '0'.toInt()

        val text = """
        for (c in "foo") println(c)
        """


        fun MString() {
            val s = "ssss"
            var str = "$s.length is ${s.length}"   //  "ssss.length is 4"

        }


    }


    fun arrayOfMinusOnes(size: Int): IntArray {
        return kotlin.IntArray(size).apply { fill(-1) }
    }

    fun printSum(a: Int, b: Int): Unit {
        println("sum of $a and $b is ${a + b}")
    }

    fun parseInt(str: String): Int? {
        return str.toIntOrNull()
    }

    fun printProduct(arg1: String, arg2: String) {
        val x = parseInt(arg1)
        val y = parseInt(arg2)

        // 直接使用 `x * y` 可能会报错，因为他们可能为 null
        if (x != null && y != null) {
            // 在空检测后，x 和 y 会自动转换为非空值（non-nullable）
            println(x * y)
        } else {
            println("either '$arg1' or '$arg2' is not a number")

        }

    }


//    fun Method() {
//        val file = File("C:/Users/Somnus/Desktop/新建文件夹")// 文件夹
//        val flist = file.listFiles()
//        if (flist == null || flist!!.size == 0) {
//            println("没有文件")
//            return
//        }
//        var i = 0
//        for (f in flist!!) {
//            var name = "文件名"// 要修改的前缀
//            if (!f.isDirectory()) {
//                val rootPath = f.getParent()
//                val fileName = f.getName()
//                name = name + i
//                val suffix = fileName.substring(fileName.lastIndexOf(".") + 1)
//                val newFile = File(rootPath + File.separator + name + "." + suffix)
//                f.renameTo(newFile)
//                i++
//
//            }
//        }
//    }

    interface Foo<out T : Any> {
        fun foo(a: Int): T
    }

    //类型后面加?表示可为空
    var age: String? = "23"
    //抛出空指针异常
    val ageInt = age!!.toInt()
    //不做处理跳过
    val ages = age?.toInt()


    //无返回值可以省略 Unit
    //public : Kotlin默认访问限制就是public 所以可以省略
    override fun onClick(view: View): Unit {
        val id = view.id
        when (id) {
            R.id.tv_hello -> print("Hello , Kotlin")
        }
    }

    /***
     *  inner
     */
    class Outer {
        private val bar: Int = 1

        class Nested {
            fun foo() = 3
        }

        inner class NestedDemo {
            fun fooNes() = 2
            fun printNo() {
                print("index  is ${fooNes()}")

            }
        }
    }

    //嵌套类不能访问外部类成员,相当于java的static 静态内部类    //创建嵌套类Nested对象,不需要外部类Outer对象
    fun printOuter() {
        val demoOuter = Outer.Nested().foo()
        print(demoOuter)
    }


    fun printNestedDemo() {
        val nest = Outer()
        //创建内部类Inner对象,需要外部类Outer对象
        nest.NestedDemo().printNo()
    }


}
